home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_300 / 364_01 / func_ca.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-05-25  |  14.1 KB  |  486 lines
  1. /*
  2. HEADER:         ;
  3. TITLE:          C-ACROSS;
  4. VERSION         1.02
  5.  
  6. DESCRIPTION:   "Utility for multiple module programs. Produces
  7.       Six indexes of functions, prototypes, and globals that
  8.       enable user to 'see across' modules for use in checking
  9.       and comparison.  One of these is type of hierarchical
  10.       functions list, a listing by module of functions
  11.       and calls made FROM them; another is alphabetical list
  12.       of functions and calls made TO them. Globals listed
  13.       in schematic descriptors which record all modifiers
  14.       and qualifiers and enable checking of declarators
  15.       across modules. Creates, on request, header file
  16.       consisting of prototypes constructed from function
  17.       definitions. Can list user types #defined and some
  18.       preprocessor #defines. Full documentation in README.CA";
  19.  
  20. KEYWORDS:       Utility, Cross Reference, Deubgging;
  21. SYSTEM:         MS-DOS;
  22. FILENAME:       FUNC_CA.C;
  23.  
  24. WARNINGS:      "1. Assumes function definitions conform with
  25.         ANSI standards and have prototype form. See
  26.         also "Caveats and Restrictions" in README.CA.
  27.         2. Assumes syntactically correct source files.
  28.         3. Written and tested using Microsoft QuickC.
  29.         4. Copyright retained.  See Copyright
  30.         information in README.CA.";
  31.  
  32. SEE-ALSO:      EXIT_CA.C,  GLOB_CA.C, IFDEF_CA.C, INTF_CA.C,
  33.            LINKL_CA.C, PARSE_CA.C, TDEF_CA.C, TYPES_CA, UTIL_CA.C,
  34.            UTLG_CA.C, XRF_CA.C, README.CA,
  35.            CA.H, CA.PRJ, CA.RPT, CDECL_CA.H, KEYWORDS.H;
  36. AUTHORS:       Myron Turner;
  37. COMPILERS:     Microsoft C;
  38.  
  39. */
  40.  
  41. /* **************************  C-ACROSS  **************************
  42.                    V. 1.02
  43.                Copyright (C) Myron Turner
  44.  
  45.               333 Bartlet Ave.
  46.               Winnipeg, Manitoba
  47.               Canada R3L 0Z9
  48.               (204) 284-8387
  49.  
  50.  ******************************************************************** */
  51.  
  52.  
  53. #include <stdio.h>
  54. #include <string.h>
  55. #include <ctype.h>
  56. #include <stdlib.h>
  57. #include <graph.h>
  58.  
  59. #define TYPEDEF_DEFINE
  60. #define TDEF_EXTERNAL
  61. #define TDEF_NUM
  62. #define INCLUDEFILES_DEFINE
  63. #include "keywords.h"
  64. #define TESTRUN
  65. #include "ca.h"
  66. #include "ca_decl.h"
  67. #define FLAG_S static short
  68. #define UINT unsigned
  69.  
  70. #define OPEN_CURLY '{'
  71. extern FILE *scrn_out;
  72. extern int declare_file ;    /* create a C declarations file: /UHF switch */
  73. extern int __mods[_MAX_MODS];
  74. extern int reading_includeF;
  75. extern UINT int inclfLine;
  76. extern UINT int inclFini;
  77.  
  78. int skipifdefn(char *p, int skipdef_status);
  79. FLAG_S functionstart(char **hold_p, char **hold_tptr);
  80. int func_def(char *p, char *module, struct func **top,
  81.                    char *big_buf, FILE *rptfp);
  82.  
  83. static struct func *syntax(char *p, char * big_buf, char *module,
  84.                  struct func *top,  FILE *rptfp);
  85.  
  86. FILE **FP_ADDRESS;
  87. int function_no = 0;
  88. int In_Parentheses = 0;
  89. int In_MainLoop = 0;
  90. struct func *function = NULL, *FirstFunction = NULL;
  91. struct includeFILE inclF;
  92.  
  93. #define BIGBUFSIZE  350 + 261
  94. #define mod_type_check_off()   __mods[0] = 0
  95. #define INPARENTHESES -1
  96.  
  97.  
  98. /*   Group of variables used by several functions in this module:  the     */
  99. /*   gloabls eliminate need to pass excessive number of function arguments */
  100. /*   for variables which are needed in and changed by several functions    */
  101.  
  102. static char *routine;
  103. FLAG_S infunction = 0;
  104. FLAG_S open_parenthesis = 0;   /* = possible function */
  105. FLAG_S buffering = 0;   /* = more than one input line in possible function */
  106. FLAG_S inner_paren= 0;  /* track of parentheses within main parenthetical  */
  107. static int brackets = 0;
  108. static UINT endfunction = 0;
  109. static struct func *previous =  NULL;
  110. static UINT bufring_line_held=0;  /* holds 1st lineno of funct'n def when */
  111.                  /* definition takes up more than one line */
  112. FLAG_S inliteral = 0;
  113. static UINT int line_count = 0,  lineno;
  114. static char *token_ptr;
  115. static int t_pos = 0, m_pos = 0;
  116. static char buffer[261];
  117.  
  118. static void ini_Globals(void);
  119.  
  120. #define DEBUG_LINE 13
  121. char *debugptr;
  122.    /**********************FUNCTIONS******************************/
  123.  
  124.   /* Main Loop for first pass */
  125. struct func *main_loop(FILE *fp, FILE *rptfp, char *module)
  126. {
  127.  static struct func *top = NULL;
  128.  char  *p, big_buf[BIGBUFSIZE];
  129.  int  __type, skip_ifdef = 0;
  130.  FILE * hold_fp = NULL;
  131.  
  132.  ini_Globals();
  133.  FP_ADDRESS = &fp;
  134.  hold_fp = fp;
  135.  
  136.  memset( big_buf, '\0', BIGBUFSIZE );
  137.  ini_if_def_stack();
  138.  
  139.   _clearscreen(0);
  140.   relocate();
  141.   if (scrn_out != (FILE *)stdout) fprintf(scrn_out,
  142.                "\n**********\n\nFirst Pass: %s\n", module);
  143.   printf("First Pass: %s\n", module);
  144.  
  145.  
  146.  
  147. /* Main loop looks for the first indicator of a function definition,    */
  148. /* which is the type specifier.  It also handles comments and strings,  */
  149. /* keeps count of curly braces, in order to determine end of             */
  150. /* function body.                                                        */
  151.  
  152. startmainloop:
  153.  
  154.   while (  fgets (buffer, 160, fp) )
  155.   {
  156.  
  157.       p = buffer;
  158.       debugptr = p;
  159.       if (!reading_includeF) line_count++;
  160.      else
  161.      inclfLine++;
  162.      if (line_count == DEBUG_LINE)
  163.                    line_count = DEBUG_LINE;
  164.  
  165.      if (inclfLine == DEBUG_LINE)
  166.                    inclfLine = DEBUG_LINE;
  167.  
  168.       skip_ifdef = skipifdefn(p, skip_ifdef);
  169.       if (skip_ifdef) goto startmainloop;
  170.  
  171.  
  172.       /* count curly brackets to determine ending line of function body    */
  173.       /* infunction is set to 1 in func_def(), when a function definition  */
  174.       /* is found.                                                         */
  175.       if (infunction && *p != '\n') {
  176.        brackets += countbrackets(buffer);
  177.        if (!brackets)
  178.            endfunction = line_count;
  179.        if (!brackets) infunction = 0;
  180.        }
  181.  
  182.       /* handle comments and strings */
  183.       do {
  184.        if ( (inliteral = isliteral(p)) ) p++;
  185.        } while ( *p && inliteral );
  186.  
  187.       if (!inliteral)
  188.     if(buffering && open_parenthesis) In_Parentheses = 1;
  189.     while (iswhite(*p)) p++;
  190.  
  191.      /* move through modifiers;  */
  192.     if (!buffering) { m_pos = _modifier (p, 0); p += m_pos; }
  193.  
  194.     /*  if next element in line is a data type check for function def */
  195.     if ( (t_pos = data_type_(p, &__type)) || open_parenthesis)
  196.         top = syntax(p, big_buf, module, top, rptfp);
  197.  
  198.  
  199.    }
  200.  
  201.   /* check to see whether we are in an include file: if so, go back to */
  202.   /* start of the main_loop                                            */
  203.   if (close_include(hold_fp, &fp, rptfp, module))
  204.             goto startmainloop;
  205.  
  206.    print_userdefs(rptfp, module);
  207.  
  208.   if (previous) previous->endfunc_line = endfunction;
  209.   free_if_def_stack();
  210.   return (top);
  211. }
  212.  
  213.  
  214. static void make_function_token(char *token_ptr, char *function_name)
  215. {
  216.   char *p = token_ptr, *function_ptr = function_name;
  217.  
  218.   while (*p == '\x20' || *p == '\x9' || *p == '*') p++;
  219.  
  220.  while (  *p && *p != ' ' && *p != '('  )
  221.      *function_ptr++ = *p++;
  222.      *function_ptr = '\0';
  223.  
  224. }
  225.  
  226.  
  227. static void print_userdefs(FILE *rptfp, char *module)
  228. {
  229.  
  230.   int i, j = 0;
  231.   char *tm[] = {"",  "Modifier", "Type" };
  232.  
  233.   fprintf(scrn_out, "\nUSER DEFINED TYPES AND MODIFIERS IN: %s ", module);
  234.   for (i = 0; i < __typedef_count; i++) {
  235.     j = (__typ_mod[i] & 0xf);
  236.     fprintf(scrn_out,"\n%d: %s [ %s ]", i, __type_def[i], tm[j]);
  237.     }
  238.  
  239.    fprintf(scrn_out, "\n");
  240.    fprintf(scrn_out, "\n");
  241.  
  242. }
  243.  
  244. #define PTR_to_FN  !In_MainLoop
  245. struct func *fill_func_struct(char *token_ptr, int lineno, char *module)
  246. {
  247.   static struct func *top = NULL;
  248.  
  249.     function = (struct func *)
  250.          malloc ( sizeof (struct func) );
  251.     function->line_no = lineno;
  252.     /* list functions in order of appearance in files */
  253.     link_by_module(function);
  254.     function->first_call = NULL;
  255.     make_function_token(token_ptr, function->name);
  256.     strcpy (function->module, module);
  257.     if (PTR_to_FN) function->fnptr = 1;
  258.           else function->fnptr = 0;
  259.     top = store_linked_list(function, top);
  260.     function_no++;
  261.  
  262.      if (!FirstFunction) FirstFunction = function;
  263.   return(top);
  264. }
  265.  
  266.  
  267.  
  268. /* This function does syntactical analysis of the input line.            */
  269. /* If line includes possible function definition,  it is sent to         */
  270. /* func_def() to determine whether it holds a function definition.       */
  271.  
  272. static struct func *syntax(char *p, char * big_buf, char *module,
  273.                      struct func *top,  FILE *rptfp)
  274. {
  275.   char *hold_p = NULL, *hold_tptr = NULL;
  276.   static int chars_to_fn_name = 0;
  277.  
  278.  
  279.     /* if we are inside parentheses, we are using the big buffer for */
  280.     /* a multiple line function definition: so we add chars_to_fn_name */
  281.     /* to pointer to beginning of buffer (routine) to move forward the */
  282.     /* token_ptr, which must point to the name of the function   */
  283.     if (t_pos == INPARENTHESES) {
  284.          token_ptr = routine + chars_to_fn_name;
  285.          t_pos = 0;
  286.          } else chars_to_fn_name = 0;
  287.  
  288.     if (!buffering)  open_parenthesis = 0;
  289.     /* if big-buffering and not inside a possible function's parentheses */
  290.     if (!open_parenthesis)
  291.     {
  292.  
  293.        hold_p = p + t_pos;  /* get past type spec */
  294.        hold_p += _modifier (hold_p, 0);  /* get past modifiers */
  295.        hold_tptr = hold_p;   /* save current position in line  */
  296.                  /* for calculating chars_to_fn_name below */
  297.  
  298.       /* Look for first open parenthesis in functionstart() as sign of */
  299.       /* possible function definition                                  */
  300.        open_parenthesis = functionstart(&hold_p, &hold_tptr);
  301.  
  302.        if (open_parenthesis && !(isalnum(*hold_tptr) || *hold_tptr == '_') )
  303.        {
  304.     /* step back if space(s) separates function name from '(' or */
  305.     /* from a preceding modifier */
  306.     while(iswhite(*hold_tptr) && hold_tptr > p + t_pos) hold_tptr--;
  307.     while( isalnum(*hold_tptr) || *hold_tptr == '_'
  308.                      && hold_tptr > p + t_pos) hold_tptr--;
  309.     if(*hold_tptr == ' ') hold_tptr++;
  310.     /* makes sure we haven't stepped back into a modifier*/
  311.     t_pos = _modifier (hold_tptr, 0);
  312.     hold_tptr += t_pos;
  313.        }
  314.  
  315.       }
  316.  
  317.     if (!chars_to_fn_name)
  318.        chars_to_fn_name = hold_tptr - p;
  319.              /* number of chars from beginning of line to         */
  320.              /* possible function name for use above              */
  321.              /*  where, if big buffer is in use we can move       */
  322.              /*  pointer chars_to_fn_name characters from start   */
  323.              /*  of line to function name                         */
  324.  
  325.     if (!buffering)  {
  326.               routine = buffer;
  327.               token_ptr = hold_tptr;
  328.               bufring_line_held = 0;
  329.               inner_paren = 0;
  330.               In_Parentheses = 0;
  331.              }
  332.                else if (open_parenthesis)
  333.               In_Parentheses = 1;
  334.  
  335.     if (!buffering) p = hold_p;
  336.  
  337.     while(*p)
  338.     {
  339.  
  340.       if (!open_parenthesis)break;
  341.  
  342.       /* if line definitely does not contain a function def, break; */
  343.       /*  otherwise continue analysis of line */
  344.       if ( *p++ == ')' && (inner_paren + 1) == 0 )
  345.         if (!strchr(p, '(') ) {
  346.          if (!func_def(p, module, &top, big_buf, rptfp)) break;
  347.          }
  348.  
  349.  
  350.       if (*p == ')' )
  351.           inner_paren--;
  352.       if (*p == '(')
  353.          inner_paren++;
  354.       if ( *p == '\n' && open_parenthesis) {
  355.       /* Multiple line declaration found.  Add each part line to    */
  356.       /* big_buf until final part is sent to func_def() where final */
  357.       /* will be added.                                             */
  358.         if (strlen(big_buf) < 350) {
  359.              strncat(big_buf, buffer, 261);
  360.              big_buf[BIGBUFSIZE] = '\0';
  361.              }
  362.         routine = big_buf;
  363.         if (!bufring_line_held) bufring_line_held = line_count;
  364.         buffering = 1;
  365.         }
  366.        else if(*p == '=' ||  strchr(p, ';') ) {
  367.          if (buffering) memset( big_buf, '\0', BIGBUFSIZE );
  368.          buffering = 0;
  369.          open_parenthesis = 0;
  370.          In_Parentheses = 0;
  371.          break;
  372.          }
  373.     }
  374.  
  375.    return(top);
  376. }
  377.  
  378.  
  379.  
  380. static void ini_Globals(void)
  381. {
  382.   mod_type_check_off();
  383.   open_parenthesis = 0;
  384.   buffering = 0;
  385.   inner_paren= 0;
  386.   brackets = 0;
  387.   infunction = 0;
  388.   endfunction = 0;
  389.   inliteral = 0;
  390.   bufring_line_held = 0;
  391.   line_count = 0;
  392.   t_pos = 0;
  393.   m_pos = 0;
  394.  
  395.   previous = NULL;
  396.  
  397.   In_MainLoop = 1;
  398.   inclF.level = 0;
  399.  
  400.  
  401.   memset ( __type_def, '\0', (__TYPEDEFSIZE * __TYPEDEFS) );
  402.   memset ( __typ_mod, 0, (__TYPEDEFSIZE * sizeof(int)) );
  403.   __typedef_count = 0;
  404.  
  405. }
  406.  
  407. FLAG_S functionstart(char **hold_p, char **hold_tptr)
  408. {
  409.  
  410.       /* check for an open parenthesis, marking start of function */
  411.       /* but stop at any other posssible delimiters  */
  412.       while (**(hold_p) && **(hold_p) != '/'
  413.         && **(hold_p) != ',' && **(hold_p) != ';')
  414.      {
  415.      if (**hold_p == ' ')
  416.         *hold_tptr = *hold_p;
  417.      (*hold_p)++;
  418.      if (**hold_p == '(')
  419.         return(1);
  420.      }
  421.  
  422.        return(0);
  423. }
  424.  
  425.  
  426. /*  The major syntactical task of this function is to check for an ending */
  427. /*  semi-colon.  If there is one, then this is not a function definition. */
  428.  
  429. int func_def(char *p, char *module, struct func **top,
  430.                    char *big_buf, FILE *rptfp)
  431. {
  432.   /* char *ptr_to_curly = NULL; */
  433.             if (*p == ')')
  434.                  p++;
  435.             if (buffering) {
  436.              paginate(rptfp);
  437.              if (strlen(big_buf) < 350) {
  438.                /* Add final part line to big_buf  */
  439.                 strncat(big_buf, buffer, 261);
  440.                 big_buf[BIGBUFSIZE] = '\0';
  441.                 }
  442.             }
  443.             open_parenthesis = 0;
  444.             buffering = 0;
  445.             while (iswhite(*p) && *p)  p++;
  446.  
  447.             /* if not function, exit but first re-set big_buf */
  448.             if (*p == ';') {
  449.             memset( big_buf, '\0', BIGBUFSIZE );
  450.             return(0);
  451.             }
  452.  
  453.  
  454.             if (previous) previous->endfunc_line = endfunction;
  455.             if (!bufring_line_held) lineno = line_count;
  456.               else {
  457.               lineno = bufring_line_held;
  458.               token_ptr += m_pos;
  459.               }
  460.             *top = fill_func_struct(token_ptr, lineno, module);
  461.             previous = function;
  462.             /* once a function declaration is found we are inside */
  463.             /* the body of a function: now we can count brackets  */
  464.             infunction = 1;
  465.  
  466.         /* Eliminate curly bracket one same line as func def:     */
  467.         /* This is just for formatting output and has             */
  468.         /* no logical function                                    */
  469.             if (*p == OPEN_CURLY) {
  470.             *p = ' ';
  471.             brackets = 1;
  472.             }
  473.  
  474.             if (declare_file ) {
  475.               *(routine + (strlen(routine) - 1) )= ';';
  476.               fprintf (rptfp, "%s\n",  routine);
  477.               }
  478.             else fprintf (rptfp, "%s",  routine);
  479.             paginate(rptfp);
  480.  
  481.  
  482.             memset( big_buf, '\0', BIGBUFSIZE );
  483.  
  484.    return (1);
  485. }
  486.